﻿// /**
//  * @File: bleota.c
//  * @Version: V1.0
//  * @Author: rudius
//  * @Brief: BLE OTA升级实现模块
//  * @Logs:
//  * 	Date		Author		Notes
//  * 	2025-07-04	rudius		first version
//  */

// // <<< Use Configuration Wizard in Context Menu >>>

// /* Private includes --------------------------------------------------------- */
// #include "bleota.h"
// #include "ymodem.h" // 包含RYM头文件
// #include <string.h>
// #include <stdlib.h>
// #include <arm_cmse.h>

// #ifdef __cplusplus
// extern "C"
// {
// #endif

// /* Private config ----------------------------------------------------------- */
// #define OTA_THREAD_STACK_SIZE 1024
// #define OTA_THREAD_PRIORITY 10
// #define OTA_THREAD_TIMESLICE 10
// #define OTA_FLASH_WRITE_SIZE 256 // Flash单次写入大小

// /* Private defines ---------------------------------------------------------- */
// #define OTA_RYM_HANDSHAKE_TIMEOUT 5 // 握手超时时间(秒)

//     /* Private typedef ---------------------------------------------------------- */
//     typedef struct
//     {
//         uint8_t *buffer;
//         rt_size_t size;
//     } ota_data_packet_t;

//     /* Private variables -------------------------------------------------------- */
//     static ota_context_t ota_ctx;
//     static uint8_t *ota_recv_buf = RT_NULL;
//     static struct mx01_device *ble_dev_cache;
//     static struct rym_ctx rym_ctx;
//     static rt_device_t rym_device = RT_NULL; // RYM使用的设备

//     /* Private function prototypes ---------------------------------------------- */
//     static void ota_worker_thread_entry(void *parameter);
//     static void ota_reset_context(void);
//     static void ota_handle_rym_event(enum rym_code code,
//                                      struct rym_ctx *ctx,
//                                      rt_uint8_t *buf,
//                                      rt_size_t len);
//     static void ota_write_flash_data(const uint8_t *data, size_t size);

//     /*----------------------------------------------------------------------------*/
//     /* Private functions -------------------------------------------------------- */

//     /**
//      * @brief OTA工作线程入口
//      */
//     static void ota_worker_thread_entry(void *parameter)
//     {
//         while (1)
//         {
//             // 等待数据就绪信号
//             if (rt_sem_take(ota_ctx.data_ready, RT_WAITING_FOREVER) == RT_EOK)
//             {
//                 rt_mutex_take(ota_ctx.lock, RT_WAITING_FOREVER);

//                 switch (ota_ctx.state)
//                 {
//                 case OTA_STATE_RECEIVING:
//                     // 写入Flash数据
//                     if (ota_recv_buf && ota_ctx.bytes_received > 0)
//                     {
//                         ota_write_flash_data(ota_recv_buf, ota_ctx.bytes_received);
//                         ota_ctx.bytes_written += ota_ctx.bytes_received;
//                         ota_ctx.bytes_received = 0; // 重置接收计数
//                     }
//                     break;

//                 case OTA_STATE_VALIDATING:
//                     // 执行固件验证
//                     if (ota_ctx.config.verify_crc)
//                     {
//                         // TODO: 实现CRC32校验
//                     }
//                     if (ota_ctx.config.verify_md5)
//                     {
//                         // TODO: 实现MD5校验
//                     }
//                     ota_ctx.state = OTA_STATE_READY;
//                     break;

//                 case OTA_STATE_READY:
//                     // 准备升级
//                     if (ota_ctx.config.auto_reboot)
//                     {
//                         ota_perform_upgrade();
//                     }
//                     break;

//                 case OTA_STATE_FAILED:
//                     // 清理失败状态
//                     ota_reset_context();
//                     break;

//                 default:
//                     break;
//                 }

//                 rt_mutex_release(ota_ctx.lock);
//             }
//         }
//     }

//     /**
//      * @brief 重置OTA上下文
//      */
//     static void ota_reset_context(void)
//     {
//         rt_mutex_take(ota_ctx.lock, RT_WAITING_FOREVER);

//         ota_ctx.state = OTA_STATE_IDLE;
//         ota_ctx.bytes_received = 0;
//         ota_ctx.bytes_written = 0;
//         ota_ctx.current_offset = ota_ctx.config.flash_base_addr;

//         // 清理元数据
//         memset(&ota_ctx.metadata, 0, sizeof(ota_metadata_t));

//         // 释放接收缓冲区
//         if (ota_recv_buf)
//         {
//             rt_free(ota_recv_buf);
//             ota_recv_buf = RT_NULL;
//         }

//         // 重置RYM上下文
//         memset(&rym_ctx, 0, sizeof(struct rym_ctx));

//         rt_mutex_release(ota_ctx.lock);
//     }

//     /**
//      * @brief RYM事件处理
//      */
//     static void ota_handle_rym_event(enum rym_code code,
//                                      struct rym_ctx *ctx,
//                                      rt_uint8_t *buf,
//                                      rt_size_t len)
//     {
//         switch (code)
//         {
//         case RYM_CODE_SOH:
//         case RYM_CODE_STX:
//             // 开始传输
//             if (ota_ctx.state == OTA_STATE_IDLE)
//             {
//                 ota_ctx.state = OTA_STATE_RECEIVING;
//             }
//             break;

//         case RYM_CODE_EOT:
//             // 结束传输
//             ota_ctx.state = OTA_STATE_VALIDATING;
//             rt_sem_release(ota_ctx.data_ready);
//             break;

//         case RYM_CODE_CAN:
//             // 中止传输
//             ota_ctx.state = OTA_STATE_FAILED;
//             rt_sem_release(ota_ctx.data_ready);
//             break;

//         case RYM_CODE_ACK:
//             // 正常确认
//             break;

//         default:
//             // 错误处理
//             if (code >= RYM_ERR_TMO && code <= RYM_ERR_ACK)
//             {
//                 ota_ctx.state = OTA_STATE_FAILED;
//                 rt_sem_release(ota_ctx.data_ready);
//             }
//             break;
//         }
//     }

//     /**
//      * @brief RYM开始回调
//      */
//     rt_weak enum rym_code ota_rym_begin_cb(struct rym_ctx *ctx, rt_uint8_t *buf, rt_size_t len)
//     {
//         // 解析文件名和文件大小
//         char *filename = (char *)buf;
//         char *filesize_str = RT_NULL;

//         // 查找文件名和大小分隔符
//         for (int i = 0; i < len; i++)
//         {
//             if (buf[i] == ' ' || buf[i] == '\0')
//             {
//                 filesize_str = (char *)buf + i + 1;
//                 buf[i] = '\0'; // 结束文件名
//                 break;
//             }
//         }

//         if (filesize_str)
//         {
//             // 解析文件大小
//             ota_ctx.metadata.size = strtoul(filesize_str, RT_NULL, 10);

//             // 验证文件大小
//             if (ota_ctx.metadata.size > ota_ctx.config.flash_max_size)
//             {
//                 rt_kprintf("File too large: %d > %d\n",
//                            ota_ctx.metadata.size,
//                            ota_ctx.config.flash_max_size);
//                 return RYM_CODE_CAN;
//             }

//             // 擦除Flash区域
//             // uint32_t sectors = (ota_ctx.metadata.size + W25QXX_SECTOR_SIZE - 1) / W25QXX_SECTOR_SIZE;
//             // for (uint32_t i = 0; i < sectors; i++)
//             // {
//                 // w25qxx_erase_sector(ota_ctx.flash_dev,
//                 //                     ota_ctx.config.flash_base_addr + i * W25QXX_SECTOR_SIZE);
//             // }
//         }

//         return RYM_CODE_ACK;
//     }

//     /**
//      * @brief RYM数据回调
//      */
//     rt_weak enum rym_code ota_rym_data_cb(struct rym_ctx *ctx, rt_uint8_t *buf, rt_size_t len)
//     {
//         rt_mutex_take(ota_ctx.lock, RT_WAITING_FOREVER);

//         // 分配接收缓冲区
//         if (ota_recv_buf == RT_NULL)
//         {
//             ota_recv_buf = rt_malloc(ota_ctx.config.buffer_size);
//             if (ota_recv_buf == RT_NULL)
//             {
//                 rt_mutex_release(ota_ctx.lock);
//                 return RYM_CODE_CAN;
//             }
//         }

//         // 检查缓冲区空间
//         if (ota_ctx.bytes_received + len > ota_ctx.config.buffer_size)
//         {
//             // 缓冲区满，通知工作线程处理
//             rt_sem_release(ota_ctx.data_ready);

//             // 等待工作线程处理
//             rt_sem_take(ota_ctx.data_ready, RT_WAITING_FOREVER);

//             // 重置接收计数
//             ota_ctx.bytes_received = 0;
//         }

//         // 复制数据到缓冲区
//         memcpy(ota_recv_buf + ota_ctx.bytes_received, buf, len);
//         ota_ctx.bytes_received += len;

//         rt_mutex_release(ota_ctx.lock);

//         return RYM_CODE_ACK;
//     }

//     /**
//      * @brief RYM结束回调
//      */
//     rt_weak enum rym_code ota_rym_end_cb(struct rym_ctx *ctx, rt_uint8_t *buf, rt_size_t len)
//     {
//         // 结束传输，开始验证
//         ota_ctx.state = OTA_STATE_VALIDATING;
//         rt_sem_release(ota_ctx.data_ready);
//         return RYM_CODE_ACK;
//     }

//     /**
//      * @brief RYM接收线程入口
//      */
//     static void ota_rym_recv_thread_entry(void *parameter)
//     {
//         rt_err_t result;
//         ota_context_t *ctx = (ota_context_t *)parameter;

//         // 设置RYM回调
//         rym_ctx.on_begin = ota_rym_begin_cb;
//         rym_ctx.on_data = ota_rym_data_cb;
//         rym_ctx.on_end = ota_rym_end_cb;

//         // 开始RYM接收
//         result = rym_recv_on_device(&rym_ctx,
//                                     rym_device,
//                                     RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_INT_RX,
//                                     rym_ctx.on_begin,
//                                     rym_ctx.on_data,
//                                     rym_ctx.on_end,
//                                     OTA_RYM_HANDSHAKE_TIMEOUT);

//         // 处理RYM结果
//         if (result != RT_EOK)
//         {
//             rt_mutex_take(ctx->lock, RT_WAITING_FOREVER);
//             ctx->state = OTA_STATE_FAILED;
//             rt_mutex_release(ctx->lock);
//             rt_sem_release(ctx->data_ready);
//         }

//         // 退出线程
//         rt_thread_delete(rt_thread_self());
//     }

//     /**
//      * @brief 写入Flash数据
//      */
//     static void ota_write_flash_data(const uint8_t *data, size_t size)
//     {
//         size_t remaining = size;
//         uint32_t addr = ota_ctx.current_offset;

//         while (remaining > 0)
//         {
//             size_t chunk = (remaining > OTA_FLASH_WRITE_SIZE) ? OTA_FLASH_WRITE_SIZE : remaining;

//             // 写入Flash
//             // w25qxx_page_program(ota_ctx.flash_dev, addr, data, chunk);

//             addr += chunk;
//             data += chunk;
//             remaining -= chunk;
//         }

//         ota_ctx.current_offset = addr;
//     }

//     /* Public functions --------------------------------------------------------- */

//     /**
//      * @brief 初始化OTA模块
//      */
//     int ota_init(const ota_config_t *config)
//     {
//         // 检查配置有效性
//         if (config == RT_NULL ||
//             config->flash_base_addr == 0 ||
//             config->buffer_size == 0)
//         {
//             return -RT_EINVAL;
//         }

//         // 初始化上下文
//         memset(&ota_ctx, 0, sizeof(ota_context_t));
//         memcpy(&ota_ctx.config, config, sizeof(ota_config_t));

//         // 创建互斥锁
//         ota_ctx.lock = rt_mutex_create("ota_mutex", RT_IPC_FLAG_PRIO);
//         if (ota_ctx.lock == RT_NULL)
//         {
//             return -RT_ENOMEM;
//         }

//         // 创建信号量
//         ota_ctx.data_ready = rt_sem_create("ota_sem", 0, RT_IPC_FLAG_PRIO);
//         if (ota_ctx.data_ready == RT_NULL)
//         {
//             rt_mutex_delete(ota_ctx.lock);
//             return -RT_ENOMEM;
//         }

//         // 创建工作线程
//         ota_ctx.worker_thread = rt_thread_create(
//             "ota_worker",
//             ota_worker_thread_entry,
//             RT_NULL,
//             OTA_THREAD_STACK_SIZE,
//             OTA_THREAD_PRIORITY,
//             OTA_THREAD_TIMESLICE);

//         if (ota_ctx.worker_thread == RT_NULL)
//         {
//             rt_mutex_delete(ota_ctx.lock);
//             rt_sem_delete(ota_ctx.data_ready);
//             return -RT_ENOMEM;
//         }

//         // 启动工作线程
//         rt_thread_startup(ota_ctx.worker_thread);

//         return RT_EOK;
//     }

//     /**
//      * @brief 启动OTA升级过程
//      */
//     int ota_start(ota_source_t source)
//     {
//         rt_mutex_take(ota_ctx.lock, RT_WAITING_FOREVER);

//         // 检查当前状态
//         if (ota_ctx.state != OTA_STATE_IDLE)
//         {
//             rt_mutex_release(ota_ctx.lock);
//             return -RT_EBUSY;
//         }

//         // 设置升级源
//         ota_ctx.source = source;

//         // 根据源类型选择设备
//         if (source == OTA_SOURCE_BLE)
//         {
//             // 获取蓝牙设备的底层UART设备
//             // 假设mx01设备结构中有对应的rt_device_t字段
//             if (ota_ctx.ble_dev && ota_ctx.ble_dev->uart_dev)
//             {
//                 rym_device = ota_ctx.ble_dev->uart_dev;
//             }
//         }
//         else // OTA_SOURCE_CLI
//         {
//             // 使用控制台设备
//             rym_device = rt_console_get_device();
//         }

//         if (rym_device == RT_NULL)
//         {
//             rt_mutex_release(ota_ctx.lock);
//             return -RT_ERROR;
//         }

//         // 创建RYM接收线程
//         rt_thread_t rym_thread = rt_thread_create(
//             "rym_recv",
//             ota_rym_recv_thread_entry,
//             &ota_ctx,
//             2048, // 需要更大的栈空间
//             OTA_THREAD_PRIORITY + 1,
//             10);

//         if (rym_thread == RT_NULL)
//         {
//             rt_mutex_release(ota_ctx.lock);
//             return -RT_ENOMEM;
//         }

//         // 启动RYM接收线程
//         rt_thread_startup(rym_thread);

//         rt_mutex_release(ota_ctx.lock);

//         return RT_EOK;
//     }

//     /**
//      * @brief 中止OTA升级过程
//      */
//     void ota_abort(void)
//     {
//         rt_mutex_take(ota_ctx.lock, RT_WAITING_FOREVER);

//         if (ota_ctx.state != OTA_STATE_IDLE &&
//             ota_ctx.state != OTA_STATE_FAILED)
//         {
//             ota_ctx.state = OTA_STATE_FAILED;

//             // 发送CAN中止传输
//             uint8_t can = RYM_CODE_CAN;
//             for (int i = 0; i < RYM_END_SESSION_SEND_CAN_NUM; i++)
//             {
//                 rt_device_write(rym_device, 0, &can, 1);
//                 rt_thread_mdelay(100);
//             }

//             // 通知工作线程
//             rt_sem_release(ota_ctx.data_ready);
//         }

//         rt_mutex_release(ota_ctx.lock);
//     }

//     /**
//      * @brief 获取当前OTA状态
//      */
//     ota_state_t ota_get_state(void)
//     {
//         return ota_ctx.state;
//     }

//     /**
//      * @brief 获取升级进度百分比
//      */
//     uint8_t ota_get_progress(void)
//     {
//         if (ota_ctx.metadata.size == 0 ||
//             ota_ctx.bytes_written == 0)
//         {
//             return 0;
//         }

//         return (uint8_t)((ota_ctx.bytes_written * 100) / ota_ctx.metadata.size);
//     }

// #include <stm32g0xx.h>
// #include <rtthread.h> // 包含RT-Thread核心函数
// #include "bleota.h"   // 包含模块自有头文件

// /**
//  * @brief 执行固件升级（安全版本）
//  */
// void ota_perform_upgrade(void)
// {
    
// }

//     /**
//      * @brief 蓝牙数据接收回调
//      */
//     void ota_ble_data_callback(struct mx01_device *dev,
//                                const uint8_t *buffer,
//                                rt_size_t size,
//                                void *context)
//     {
//         // 此函数在RYM模式下不需要
//         // RYM会直接从设备读取数据
//     }

// /********************** CLI命令接口 **********************/
// #ifdef RT_USING_FINSH
// #include <finsh.h>

//     /**
//      * @brief MSH命令: 启动OTA升级
//      */
//     void ota_start_cli(void)
//     {
//         ota_start(OTA_SOURCE_CLI);
//     }
//     MSH_CMD_EXPORT(ota_start_cli, Start OTA upgrade via CLI);

//     /**
//      * @brief MSH命令: 显示OTA状态
//      */
//     void ota_status_cli(void)
//     {
//         rt_kprintf("OTA State: ");
//         switch (ota_get_state())
//         {
//         case OTA_STATE_IDLE:
//             rt_kprintf("Idle\n");
//             break;
//         case OTA_STATE_RECEIVING:
//             rt_kprintf("Receiving [%d%%]\n", ota_get_progress());
//             break;
//         case OTA_STATE_VALIDATING:
//             rt_kprintf("Validating\n");
//             break;
//         case OTA_STATE_READY:
//             rt_kprintf("Ready to upgrade\n");
//             break;
//         case OTA_STATE_FAILED:
//             rt_kprintf("Failed\n");
//             break;
//         case OTA_EVENT_ABORT:
//             rt_kprintf("Aborted\n");
//             break;
//         case OTA_EVENT_DATA:
//             rt_kprintf("data event\n");
//             break;
//         case OTA_EVENT_START:
//             rt_kprintf("start event\n");
//             break;
//         default:
//             rt_kprintf("Unknown\n");
//             break;
//         }
//     }
//     MSH_CMD_EXPORT(ota_status_cli, Show OTA status);

//     /**
//      * @brief MSH命令: 中止OTA升级
//      */
//     void ota_abort_cli(void)
//     {
//         ota_abort();
//         rt_kprintf("OTA aborted\n");
//     }
//     MSH_CMD_EXPORT(ota_abort_cli, Abort OTA upgrade);
// #endif /* RT_USING_FINSH */

// #ifdef __cplusplus
// }
// #endif
// // <<< end of configuration section >>>
// /* ----------------------------- end of bleota.c ---------------------------- */